# search.py
# ---------
# Licensing Information: Please do not distribute or publish solutions to this
# project. You are free to use and extend these projects for educational
# purposes. The Pacman AI projects were developed at UC Berkeley, primarily by
# John DeNero (denero@cs.berkeley.edu) and Dan Klein (klein@cs.berkeley.edu).
# For more info, see http://inst.eecs.berkeley.edu/~cs188/sp09/pacman.html

"""
In search.py, you will implement generic search algorithms which are called
by Pacman agents (in searchAgents.py).
"""

import util

class SearchProblem:
    """
    This class outlines the structure of a search problem, but doesn't implement
    any of the methods (in object-oriented terminology: an abstract class).

    You do not need to change anything in this class, ever.
    """

    def getStartState(self):
        """
        Returns the start state for the search problem
        """
        util.raiseNotDefined()

    def isGoalState(self, state):
        """
          state: Search state

        Returns True if and only if the state is a valid goal state
        """
        util.raiseNotDefined()

    def getSuccessors(self, state):
        """
          state: Search state

        For a given state, this should return a list of triples,
        (successor, action, stepCost), where 'successor' is a
        successor to the current state, 'action' is the action
        required to get there, and 'stepCost' is the incremental
        cost of expanding to that successor
        """
        util.raiseNotDefined()

    def getCostOfActions(self, actions):
        """
         actions: A list of actions to take

        This method returns the total cost of a particular sequence of actions.  The sequence must
        be composed of legal moves
        """
        util.raiseNotDefined()


def tinyMazeSearch(problem):
    """
    Returns a sequence of moves that solves tinyMaze.  For any other
    maze, the sequence of moves will be incorrect, so only use this for tinyMaze
    """
    from game import Directions
    s = Directions.SOUTH
    w = Directions.WEST
    return  [s,s,w,s,w,w,s,w]

def depthFirstSearch(problem):
    """
    Search the deepest nodes in the search tree first
    [2nd Edition: p 75, 3rd Edition: p 87]

    Your search algorithm needs to return a list of actions that reaches
    the goal.  Make sure to implement a graph search algorithm
    [2nd Edition: Fig. 3.18, 3rd Edition: Fig 3.7].

    To get started, you might want to try some of these simple commands to
    understand the search problem that is being passed in:

    print "Start:", problem.getStartState()
    print "Is the start a goal?", problem.isGoalState(problem.getStartState())
    print "Start's successors:", problem.getSuccessors(problem.getStartState())
    """
    "*** YOUR CODE HERE ***"
    
    stack = util.Stack()
    path = []
    setPreviouslySeen = set()
    stack.push(problem.getStartState())
    parentNode = stack.pop()
    counter = 0
    path.append([0,0])
    
    if problem.isGoalState(parentNode):
        return []
    
    setPreviouslySeen.add(parentNode)
    
    for child in problem.getSuccessors(parentNode):
        setPreviouslySeen.add(child[0])
        stack.push((child, counter))
        
    
        
    while(stack.isEmpty()!=True):
        temp = stack.pop()
        childNode = temp[0]
        counterTemp = temp[1]
        counter = counter + 1
        path.append((childNode[1],counterTemp))
        if problem.isGoalState(childNode[0]):
            print 'goalllll'
            return pathFinder(path)
        for grandChild in problem.getSuccessors(childNode[0]):
            if grandChild[0] not in setPreviouslySeen:
                setPreviouslySeen.add(grandChild[0])
                stack.push((grandChild, counter))
    
    

def breadthFirstSearch(problem):
    """
    Search the shallowest nodes in the search tree first.
    [2nd Edition: p 73, 3rd Edition: p 82]
    """
    "*** YOUR CODE HERE ***"
    queue = util.Queue()
    path = []
    setPreviouslySeen = set()
    queue.push(problem.getStartState())
    parentNode = queue.pop()
    counter = 0
    path.append([0,0])
    
    if problem.isGoalState(parentNode):
        return []
    
    setPreviouslySeen.add(parentNode)
    
    for child in problem.getSuccessors(parentNode):
        setPreviouslySeen.add(child[0])
        queue.push((child, counter))
        
    
        
    while(queue.isEmpty()!=True):
        temp = queue.pop()
        childNode = temp[0]
        counterTemp = temp[1]
        counter = counter + 1
        path.append((childNode[1],counterTemp))
        if problem.isGoalState(childNode[0]):
            print 'goalllll'
            return pathFinder(path)
        for grandChild in problem.getSuccessors(childNode[0]):
            if grandChild[0] not in setPreviouslySeen:
                setPreviouslySeen.add(grandChild[0])
                queue.push((grandChild, counter))


def uniformCostSearch(problem):

    "Search the node of least total cost first. "

    "*** YOUR CODE HERE ***"

    priorityQueue = util.PriorityQueue()
    path = []
    setPreviouslySeen = set()
    path.append([0,0])
    counter = 0
    priorityQueue.push(((problem.getStartState(), 0, 0), 0), 0)
   # setPreviouslySeen.add(problem.getStartState)

    while(priorityQueue.isEmpty()!=True):
        temp = priorityQueue.pop()
        childNode = temp[0]
        counterTemp = temp[1]
        counter = counter + 1
  
        path.append((childNode[1],counterTemp))

        if problem.isGoalState(childNode[0]):
            print counter
            return pathFinder(path)
        
        setPreviouslySeen.add(childNode[0]) 
              
        for grandChild in problem.getSuccessors(childNode[0]):
            if grandChild[0] not in setPreviouslySeen:
     #           setPreviouslySeen.add(grandChild[0])
                priorityQueue.push((grandChild, counter), problem.getCostOfActions(pathFinder(path))+grandChild[2])
                
def nullHeuristic(state, problem=None):
    """
    A heuristic function estimates the cost from the current state to the nearest
    goal in the provided SearchProblem.  This heuristic is trivial.
    """
    return 0

def aStarSearch(problem, heuristic=nullHeuristic):
    "Search the node that has the lowest combined cost and heuristic first."
    "*** YOUR CODE HERE ***"
    priorityQueueWithFunction = util.PriorityQueueWithFunction(function)
    path = []
    setPreviouslySeen = set()
    path.append([0,0])
    counter = 0
    startStateTriple = (problem.getStartState(),0,0)
    print problem.getStartState()[1]
    priorityQueueWithFunction.push(tuple(((startStateTriple, counter), (heuristic(startStateTriple[0], problem)))))

  
    while(priorityQueueWithFunction.isEmpty()!=True):
        temp = priorityQueueWithFunction.pop()
        childNode = temp[0][0]
        counterTemp = temp[0][1]
        counter = counter + 1
  
        path.append((childNode[1],counterTemp))

        if problem.isGoalState(childNode[0]):
            return pathFinder(path)
        
        setPreviouslySeen.add(childNode[0]) 
              
        for grandChild in problem.getSuccessors(childNode[0]):
            if grandChild[0] not in setPreviouslySeen:
                priorityQueueWithFunction.push(tuple(((grandChild, counter), problem.getCostOfActions(pathFinder(path))+grandChild[2]+heuristic(grandChild[0], problem))))
                
def function (item):
    state, result = item
     
    return result


def pathFinder(list):
    counter = len(list) - 1 #15
    state = list[counter] #['West',14]
    direction = state[0] #'West'
    index = state[1] #14
    result = []
    result.insert(0,direction) #['West']

    while (direction != 0):
        nextState = list[index]
        nextDirection = nextState[0]
        nextIndex = nextState[1]
        result.insert(0, nextDirection)
        direction = nextDirection
        index = nextIndex
                
    result.remove(0)   
    return result

# Abbreviations
bfs = breadthFirstSearch
dfs = depthFirstSearch
astar = aStarSearch
ucs = uniformCostSearch
